home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / distutils / filelist.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  11KB  |  300 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. '''distutils.filelist
  5.  
  6. Provides the FileList class, used for poking about the filesystem
  7. and building lists of files.
  8. '''
  9. __revision__ = '$Id: filelist.py,v 1.18 2004/11/10 22:23:14 loewis Exp $'
  10. import os
  11. import string
  12. import re
  13. import fnmatch
  14. from types import *
  15. from glob import glob
  16. from distutils.util import convert_path
  17. from distutils.errors import DistutilsTemplateError, DistutilsInternalError
  18. from distutils import log
  19.  
  20. class FileList:
  21.     """A list of files built by on exploring the filesystem and filtered by
  22.     applying various patterns to what we find there.
  23.  
  24.     Instance attributes:
  25.       dir
  26.         directory from which files will be taken -- only used if
  27.         'allfiles' not supplied to constructor
  28.       files
  29.         list of filenames currently being built/filtered/manipulated
  30.       allfiles
  31.         complete list of files under consideration (ie. without any
  32.         filtering applied)
  33.     """
  34.     
  35.     def __init__(self, warn = None, debug_print = None):
  36.         self.allfiles = None
  37.         self.files = []
  38.  
  39.     
  40.     def set_allfiles(self, allfiles):
  41.         self.allfiles = allfiles
  42.  
  43.     
  44.     def findall(self, dir = os.curdir):
  45.         self.allfiles = findall(dir)
  46.  
  47.     
  48.     def debug_print(self, msg):
  49.         """Print 'msg' to stdout if the global DEBUG (taken from the
  50.         DISTUTILS_DEBUG environment variable) flag is true.
  51.         """
  52.         DEBUG = DEBUG
  53.         import distutils.debug
  54.         if DEBUG:
  55.             print msg
  56.         
  57.  
  58.     
  59.     def append(self, item):
  60.         self.files.append(item)
  61.  
  62.     
  63.     def extend(self, items):
  64.         self.files.extend(items)
  65.  
  66.     
  67.     def sort(self):
  68.         sortable_files = map(os.path.split, self.files)
  69.         sortable_files.sort()
  70.         self.files = []
  71.         for sort_tuple in sortable_files:
  72.             self.files.append(apply(os.path.join, sort_tuple))
  73.         
  74.  
  75.     
  76.     def remove_duplicates(self):
  77.         for i in range(len(self.files) - 1, 0, -1):
  78.             if self.files[i] == self.files[i - 1]:
  79.                 del self.files[i]
  80.                 continue
  81.         
  82.  
  83.     
  84.     def _parse_template_line(self, line):
  85.         words = string.split(line)
  86.         action = words[0]
  87.         patterns = None
  88.         dir = None
  89.         dir_pattern = None
  90.         if action in ('include', 'exclude', 'global-include', 'global-exclude'):
  91.             if len(words) < 2:
  92.                 raise DistutilsTemplateError, "'%s' expects <pattern1> <pattern2> ..." % action
  93.             
  94.             patterns = map(convert_path, words[1:])
  95.         elif action in ('recursive-include', 'recursive-exclude'):
  96.             if len(words) < 3:
  97.                 raise DistutilsTemplateError, "'%s' expects <dir> <pattern1> <pattern2> ..." % action
  98.             
  99.             dir = convert_path(words[1])
  100.             patterns = map(convert_path, words[2:])
  101.         elif action in ('graft', 'prune'):
  102.             if len(words) != 2:
  103.                 raise DistutilsTemplateError, "'%s' expects a single <dir_pattern>" % action
  104.             
  105.             dir_pattern = convert_path(words[1])
  106.         else:
  107.             raise DistutilsTemplateError, "unknown action '%s'" % action
  108.         return (action, patterns, dir, dir_pattern)
  109.  
  110.     
  111.     def process_template_line(self, line):
  112.         (action, patterns, dir, dir_pattern) = self._parse_template_line(line)
  113.         if action == 'include':
  114.             self.debug_print('include ' + string.join(patterns))
  115.             for pattern in patterns:
  116.                 if not self.include_pattern(pattern, anchor = 1):
  117.                     log.warn("warning: no files found matching '%s'", pattern)
  118.                     continue
  119.             
  120.         elif action == 'exclude':
  121.             self.debug_print('exclude ' + string.join(patterns))
  122.             for pattern in patterns:
  123.                 if not self.exclude_pattern(pattern, anchor = 1):
  124.                     log.warn("warning: no previously-included files found matching '%s'", pattern)
  125.                     continue
  126.             
  127.         elif action == 'global-include':
  128.             self.debug_print('global-include ' + string.join(patterns))
  129.             for pattern in patterns:
  130.                 if not self.include_pattern(pattern, anchor = 0):
  131.                     log.warn("warning: no files found matching '%s' " + 'anywhere in distribution', pattern)
  132.                     continue
  133.             
  134.         elif action == 'global-exclude':
  135.             self.debug_print('global-exclude ' + string.join(patterns))
  136.             for pattern in patterns:
  137.                 if not self.exclude_pattern(pattern, anchor = 0):
  138.                     log.warn("warning: no previously-included files matching '%s' found anywhere in distribution", pattern)
  139.                     continue
  140.             
  141.         elif action == 'recursive-include':
  142.             self.debug_print('recursive-include %s %s' % (dir, string.join(patterns)))
  143.             for pattern in patterns:
  144.                 if not self.include_pattern(pattern, prefix = dir):
  145.                     log.warn("warning: no files found matching '%s' " + "under directory '%s'", pattern, dir)
  146.                     continue
  147.             
  148.         elif action == 'recursive-exclude':
  149.             self.debug_print('recursive-exclude %s %s' % (dir, string.join(patterns)))
  150.             for pattern in patterns:
  151.                 if not self.exclude_pattern(pattern, prefix = dir):
  152.                     log.warn("warning: no previously-included files matching '%s' found under directory '%s'", pattern, dir)
  153.                     continue
  154.             
  155.         elif action == 'graft':
  156.             self.debug_print('graft ' + dir_pattern)
  157.             if not self.include_pattern(None, prefix = dir_pattern):
  158.                 log.warn("warning: no directories found matching '%s'", dir_pattern)
  159.             
  160.         elif action == 'prune':
  161.             self.debug_print('prune ' + dir_pattern)
  162.             if not self.exclude_pattern(None, prefix = dir_pattern):
  163.                 log.warn('no previously-included directories found ' + "matching '%s'", dir_pattern)
  164.             
  165.         else:
  166.             raise DistutilsInternalError, "this cannot happen: invalid action '%s'" % action
  167.  
  168.     
  169.     def include_pattern(self, pattern, anchor = 1, prefix = None, is_regex = 0):
  170.         '''Select strings (presumably filenames) from \'self.files\' that
  171.         match \'pattern\', a Unix-style wildcard (glob) pattern.  Patterns
  172.         are not quite the same as implemented by the \'fnmatch\' module: \'*\'
  173.         and \'?\'  match non-special characters, where "special" is platform-
  174.         dependent: slash on Unix; colon, slash, and backslash on
  175.         DOS/Windows; and colon on Mac OS.
  176.  
  177.         If \'anchor\' is true (the default), then the pattern match is more
  178.         stringent: "*.py" will match "foo.py" but not "foo/bar.py".  If
  179.         \'anchor\' is false, both of these will match.
  180.  
  181.         If \'prefix\' is supplied, then only filenames starting with \'prefix\'
  182.         (itself a pattern) and ending with \'pattern\', with anything in between
  183.         them, will match.  \'anchor\' is ignored in this case.
  184.  
  185.         If \'is_regex\' is true, \'anchor\' and \'prefix\' are ignored, and
  186.         \'pattern\' is assumed to be either a string containing a regex or a
  187.         regex object -- no translation is done, the regex is just compiled
  188.         and used as-is.
  189.  
  190.         Selected strings will be added to self.files.
  191.  
  192.         Return 1 if files are found.
  193.         '''
  194.         files_found = 0
  195.         pattern_re = translate_pattern(pattern, anchor, prefix, is_regex)
  196.         self.debug_print("include_pattern: applying regex r'%s'" % pattern_re.pattern)
  197.         if self.allfiles is None:
  198.             self.findall()
  199.         
  200.         for name in self.allfiles:
  201.             if pattern_re.search(name):
  202.                 self.debug_print(' adding ' + name)
  203.                 self.files.append(name)
  204.                 files_found = 1
  205.                 continue
  206.         
  207.         return files_found
  208.  
  209.     
  210.     def exclude_pattern(self, pattern, anchor = 1, prefix = None, is_regex = 0):
  211.         """Remove strings (presumably filenames) from 'files' that match
  212.         'pattern'.  Other parameters are the same as for
  213.         'include_pattern()', above.
  214.         The list 'self.files' is modified in place.
  215.         Return 1 if files are found.
  216.         """
  217.         files_found = 0
  218.         pattern_re = translate_pattern(pattern, anchor, prefix, is_regex)
  219.         self.debug_print("exclude_pattern: applying regex r'%s'" % pattern_re.pattern)
  220.         for i in range(len(self.files) - 1, -1, -1):
  221.             if pattern_re.search(self.files[i]):
  222.                 self.debug_print(' removing ' + self.files[i])
  223.                 del self.files[i]
  224.                 files_found = 1
  225.                 continue
  226.         
  227.         return files_found
  228.  
  229.  
  230.  
  231. def findall(dir = os.curdir):
  232.     """Find all files under 'dir' and return the list of full filenames
  233.     (relative to 'dir').
  234.     """
  235.     ST_MODE = ST_MODE
  236.     S_ISREG = S_ISREG
  237.     S_ISDIR = S_ISDIR
  238.     S_ISLNK = S_ISLNK
  239.     import stat
  240.     list = []
  241.     stack = [
  242.         dir]
  243.     pop = stack.pop
  244.     push = stack.append
  245.     while stack:
  246.         dir = pop()
  247.         names = os.listdir(dir)
  248.         for name in names:
  249.             if dir != os.curdir:
  250.                 fullname = os.path.join(dir, name)
  251.             else:
  252.                 fullname = name
  253.             stat = os.stat(fullname)
  254.             mode = stat[ST_MODE]
  255.             if S_ISREG(mode):
  256.                 list.append(fullname)
  257.                 continue
  258.             if S_ISDIR(mode) and not S_ISLNK(mode):
  259.                 push(fullname)
  260.                 continue
  261.         
  262.     return list
  263.  
  264.  
  265. def glob_to_re(pattern):
  266.     '''Translate a shell-like glob pattern to a regular expression; return
  267.     a string containing the regex.  Differs from \'fnmatch.translate()\' in
  268.     that \'*\' does not match "special characters" (which are
  269.     platform-specific).
  270.     '''
  271.     pattern_re = fnmatch.translate(pattern)
  272.     pattern_re = re.sub('(^|[^\\\\])\\.', '\\1[^/]', pattern_re)
  273.     return pattern_re
  274.  
  275.  
  276. def translate_pattern(pattern, anchor = 1, prefix = None, is_regex = 0):
  277.     """Translate a shell-like wildcard pattern to a compiled regular
  278.     expression.  Return the compiled regex.  If 'is_regex' true,
  279.     then 'pattern' is directly compiled to a regex (if it's a string)
  280.     or just returned as-is (assumes it's a regex object).
  281.     """
  282.     if is_regex:
  283.         if type(pattern) is StringType:
  284.             return re.compile(pattern)
  285.         else:
  286.             return pattern
  287.     
  288.     if pattern:
  289.         pattern_re = glob_to_re(pattern)
  290.     else:
  291.         pattern_re = ''
  292.     if prefix is not None:
  293.         prefix_re = glob_to_re(prefix)[0:-1]
  294.         pattern_re = '^' + os.path.join(prefix_re, '.*' + pattern_re)
  295.     elif anchor:
  296.         pattern_re = '^' + pattern_re
  297.     
  298.     return re.compile(pattern_re)
  299.  
  300.